Java基础知识(二)

Author Avatar
子语 2017 - 09 - 24
  • 在其它设备中阅读本文章

运算符

常用运算符：四则运算符、逻辑运算符、三目运算符和位运算符。

基本运算符

  1. =为赋值运算符。
  2. 四则运算符基本组成：+、-、*、/、%。不要使用运算符编写过于复杂的计算。
public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        double numB = 20;
        int numC = 3;
        System.out.println("加法计算：" + (numA + numB));
        System.out.println("减法计算：" + (numA - numB));
        System.out.println("乘法计算：" + (numA * numB));
        System.out.println("除法计算：" + (numA / numB));
        System.out.println("求模计算：" + (numA % numC));
    }
}
  1. 简化运算符：+=、-=、*=、/=、%=:
public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        numA += 2; // 等同于 numA = numA + 2
        System.out.println("加法计算" + (numA)); // 12
    }
}
  1. ++（自增），--（自减）：位置不同，功能也不同：
    ·++变量，--变量：先对变量加/减1，再使用自增或自减后的变量进行计算;
    ·变量++，变量--：先使用变量进行计算，再进行变量加/减1。
public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        int numB = 20;
        // ++变量，先numA + 1
        // 然后(numA + 1) + numB内容
        // 最后对numB加1
        int result = (++numA) + (numB++);
        System.out.println("numA=" + numA); // 11
        System.out.println("numB=" + numB); // 21
        System.out.println("result=" + result); // 31
    }
}

三目运算符

三目运算符根据布尔表达式的结果进行赋值：

value_type value_name = 布尔表达式 ? true_value : false_value;

利用三目运算符可以减少判断代码:

public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        int numB = 20;
        int max = 0;
        /** 使用三目运算符
         *  当numA大于numB,返回true,max = numA
         *  当numA小于numB,返回false,max = numB
         */
        max = numA>numB ? numA : numB;
        // 不使用三目运算符
        // if (numA > numB) {
        //    max = numA;
        //} else {
        //    max = numB;
        //}
        System.out.println(max);
    }
}

逻辑运算符

  1. 逻辑运算符：与&，&&、或|，||、非!
package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        boolean flag = true;
        System.out.println(!flag); // false
    }
}
  1. 布尔表达式的连接，只能使用与和或操作

与：所有条件都为true时，结果为true;有一个为false，结果就是false.

范例：普通与&

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 除数不能为0
        if ((1 == 2) & (10 / 0 == 0)){
            System.out.println("Hello"); // 报错
        }
    }
}

结果：程序报错，因为&会对所有条件进行判断。但就与的特点而言，前一个条件为false，结果就是false，后续的判断没有意义。
范例：短路与&&

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 除数不能为0
        if ((1 == 2) && (10 / 0 == 0)){
            System.out.println("Hello"); // false,不报错
        }
    }
}

结果:程序不报错，因为&&只要有一个条件为false后，后续判断就不再进行，从而提高了效率。

或操作：一个条件为true，结果为true。

范例：普通或|

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        if ((1 < 2 ) | (10 / 0 == 0)){
            System.out.println("Hello"); // 报错
        }
    }
}

结果：使用|，会对所有条件进行判断，但是或运算的特点是：一个条件为true，结果就是true。
范例：短路或||

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        if ((1 < 2 ) || (10 / 0 == 0)){
            System.out.println("Hello"); // true,不报错
        }
    }
}

因此使用逻辑运算时就使用&&和||。

位运算符

  1. 数学计算为十进制。Java支持二进制、八进制和十六进制。如果要想将十进制变为二进制，采用的方式为：除2，取余，倒序。
  2. 位运算主要是进行二进制数据操作，位运算符：&、|、>>(移位)、<<、^(反码)、~。
    范例：位与&
package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int numA = 9;
        int numB = 11;
        System.out.println(numA & numB); // 9
    }
}

运算过程：

  1001 → 9
& 1011 → 11
  1001 →  9

范例：位或|

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int numA = 9;
        int numB = 11;
        System.out.println(numA | numB); // 11
    }
}

运算过程：

  1001 → 9
| 1011 → 11
  1011 → 11

范例：移位（最快方式计算2的3次方）

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int num = 2;
        num = num << 2; // 向左移位
        System.out.println(num); // 8,相当于2的3次方
    }
}

运算过程：

    0010 → 2
2<< 1000 → 8

章节小问题：请解释&与&&的区别，以及|与||的区别:
1. 在逻辑运算中：
  |- &和|会对所有条件进行判断后，返回结果
  |- &&只要一个条件返回false，就不进行后续判断，结果为false
  |- ||只要一个条件为true，就不进行后续判断，结果为true
2. 在位运算中：
  |- &为位与元算，|为位或元算
  |- &&和||不能用于位运算

Java程序逻辑控制

程序逻辑结构主要分为三种：顺序结构、分支结构、循环结构。顺序结构执行顺序是从前到后，但有时是以代码所在的{}为界限。

分支结构

  1. 分支结构即判断结构，有两种语法：if和switch.
  2. if语句:
    if语句的格式:
if if…else if…else if…else

范例：if判断

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        double score = 90.0;
        if (score < 60.0) {
            System.out.println("不及格");
        } else if (score < 90) {
            System.out.println("良");
        } else {
            System.out.println("优秀");
        }
    }
}
  1. switch语句:
    switch判断不能使用布尔表达式，JDK1.5之前只能进行整数或字符判断，JDK1.5增加了枚举判断，JDK1.7增加了String判断，语法：
switch (数字/字符/枚举/字符串){
    case 内容 : 内容满足时执行的代码 ; break;
    case 内容 : 内容满足时执行的代码 ; break;
    ...
    default {
        内容都不满足case时执行;
        break;
    }
}

范例：使用switch

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("数字1");
                break;
            case 2:
                System.out.println("数字2");
                break;
            default:
                System.out.println("大于2的数字");
                break;
        }
    }
}

switch默认从第一个符合条件的case语句开始执行，直到整个switch执行完毕或遇到break关键字，才停止执行。程序区分大小写。

循环结构

  1. 当某段代码需要重复执行时，可使用循环语句实现，循环有两种：for循环和while循环。
  2. while循环：
while循环 do…while循环
while（布尔语句）｛｝ do｛｝while（布尔语句);

范例：实现1到100的累加（while循环先判断再执行）：

package com.java.demo;
public class Demo {
   public static void main(String[] args) {
       int sum = 0;
       int current = 1; // 循环的初始化条件
       while (current <= 100) { // 循环结束条件
           sum += current; // 累加
           current++; // 修改循环的初始化条件
       }
       System.out.println(sum); // 5050
   }
}

范例：实现1到100的累加（do…while循环是先执行再判断）

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        int current = 1;
        do {
            sum += current;
            current++;
        } while (current <= 100);
        System.out.println(sum);
    }
}

do…while循环先执行再判断，即不论循环条件是否满足，都至少执行一次，因此开发中不建议使用do…while。

  1. for循环：
for (循环初始化条件; 循环结束条件; 循环条件变更) {
    循环语句;
}

即使三个条件都不写，但是两个";"必须保留。
范例：实现1~100的累加

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}
  1. 开发原则:
    （1）循环次数未知，循环结束条件已知时使用while循环；
    （2）循环次数已知，使用for循环。
  2. 循环嵌套
public class 九九乘法表 {
    public static void main(String[] args) {
        for (int x = 1; x <= 9; x++) {
            for (int y = 1; y <= x; y++) {
                System.out.print(x + "*" + y + "=" + (x * y) + "\t");
            }
            System.out.println();
        }
    }
}

循环控制

循环控制有两个语句：continue（退出本次循环）和break（结束整个循环）。该语句要和判断语句一起使用。
范例：continue使用

package com.java.demo;
public class Demo {
   public static void main(String[] args) {
       for (int x = 0; x < 5; x++) {
           if (x == 3) {
               continue; // 跳出本次循环，不进行后续的输出操作
           }
           System.out.print(x + ","); // 0,1,2,4,
       }
   }
}

范例：break

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        for (int x = 0; x < 5; x++) {
            if (x == 3) {
                break; // 结束整体循环
            }
            System.out.print(x + ","); // 0,1,2,
        }
    }
}

This blog is under a CC BY-NC-SA 3.0 Unported License
本文链接：http://yov.oschina.io/article/Java/Java Base/Java基础知识(二)/